home *** CD-ROM | disk | FTP | other *** search
/ Mission 3 / Mission 3.zip / Mission 3.iso / texte / qed / src / kurzel.c < prev    next >
C/C++ Source or Header  |  1998-09-29  |  9KB  |  441 lines
  1. #include "global.h"
  2. #include "edit.h"
  3. #include "file.h"
  4. #include "icon.h"
  5. #include "memory.h"
  6. #include "menu.h"
  7. #include "options.h"
  8. #include "rsc.h"
  9. #include "tasten.h"
  10. #include "text.h"
  11. #include "window.h"
  12. #include "kurzel.h"
  13.  
  14. /*
  15.  * Exportierte Variablen
  16.  */
  17. bool    krz_loaded;
  18.  
  19. /**************************************************************************/
  20.  
  21.  
  22. #define MNAME_LEN        12
  23. #define KRZ_MAX_LEN    8
  24.  
  25. typedef struct
  26. {
  27.     char    name[MNAME_LEN+1];
  28.     PATH    file;
  29.     long    y;
  30.     int    x;
  31. }MARKE, *MARKEP;
  32.  
  33. #define KRZ_LEN(col)    (TEXT(col)[0])
  34. #define KRZ_TXT(col)    (TEXT(col)+1)
  35. #define ERSATZ(col)    (TEXT(col)+1+KRZ_MAX_LEN+1)
  36.  
  37. static RING        kurz;
  38. /* Sortierte Zeilen                                                                 */
  39. /* Am Anfang in umgedrehter Reihenfolge die Zeichen                     */
  40. /* des Kürzel als Null-Terminierender String                                 */
  41. /* davor noch die länge des Kürzel (Pascalähnlich)                        */
  42. /* 0 Kürzellänge, 1-9 Kürzel, ab der 10 Position der Ersatzstring    */
  43. static RING    auto_kurz;
  44.  
  45. static MARKE    Marken[MARKEN_ANZ];
  46.  
  47. static PATH        krz_name;    /* Name der aktuellen Kürzeldatei, oder leer */
  48.  
  49. /***************************************************************************/
  50. static void    go_to_marke    (int nr);
  51.  
  52. static int  load_kurzel    (void);
  53. static void clr_kurzel    (void);
  54. static int  add_kurzel    (ZEILEP col);
  55.  
  56. /***************************************************************************/
  57.  
  58. bool goto_line_dial (void)
  59. {
  60.     int    antw;
  61.     char    s[12];
  62.  
  63.     set_string(pos, GZEILE, "");
  64.     set_string(pos, GSPALTE, "");
  65.     antw = simple_mdial(pos, GZEILE) & 0x7fff;
  66.     if (antw == GOK)
  67.     {
  68.         get_string(pos, GZEILE, s);
  69.         if (s[0] != EOS)
  70.             desire_y = atol(s) - 1;
  71.         else
  72.             desire_y = 0L;
  73.         get_string(pos, GSPALTE, s);
  74.         if (s[0] != EOS)
  75.             desire_x = atoi(s) - 1;
  76.         else
  77.             desire_x = 0;
  78.         return TRUE;
  79.     }
  80.     return FALSE;
  81. }
  82.  
  83. /***************************************************************************/
  84. /* Verwaltung der Marken                                                                    */
  85. /***************************************************************************/
  86.  
  87. void del_marke(int nr)
  88. {
  89.     MARKEP    m;
  90.     char        *str;
  91.     int        len;
  92.  
  93.     if (nr >= 0 && nr < MARKEN_ANZ)
  94.     {
  95.         m = Marken + nr;
  96.         m->file[0] = EOS;
  97.         m->name[0] = EOS;
  98.         str = menu[MMARKE1+nr].ob_spec.free_string + 5;
  99.         len = MNAME_LEN;
  100.         while ((--len)>=0)
  101.             *str++ = ' ';
  102.     }
  103. }
  104.  
  105. void set_marke(int nr, char *name, PATH file, long y, int x)
  106. {
  107.     MARKEP    m;
  108.  
  109.     if (nr >= 0 && nr < MARKEN_ANZ)
  110.     {
  111.         m = Marken + nr;
  112.         m->x = x;
  113.         m->y = y;
  114.         strncpy(m->name, name, MNAME_LEN);
  115.         m->name[MNAME_LEN] = EOS;
  116.         strcpy(m->file, file);
  117.         fillup_menu(MMARKE1 + nr, name, 5);
  118.     }
  119. }
  120.  
  121. bool get_marke(int nr, char *name, PATH file, long *y, int *x)
  122. {
  123.     file[0] = EOS;
  124.     if (nr >= 0 && nr < MARKEN_ANZ)
  125.     {
  126.         MARKEP    m;
  127.  
  128.         m = Marken+nr;
  129.         *x = m->x;
  130.         *y = m->y;
  131.         strncpy(name, m->name, MNAME_LEN);
  132.         name[MNAME_LEN] = EOS;
  133.         strcpy(file, m->file);
  134.     }
  135.     return (file[0] != EOS);
  136. }
  137.  
  138. void init_marken(void)
  139. {
  140.     int        i;
  141.     MARKEP    m;
  142.  
  143.     for (i = MARKEN_ANZ, m = Marken; (--i)>=0; m++)
  144.     {
  145.         m->file[0] = EOS;
  146.         m->name[0] = EOS;
  147.     }
  148.     init_textring(&kurz);
  149.     init_textring(&auto_kurz);
  150. }
  151.  
  152. void goto_marke(int nr)
  153. {
  154.     PATH    file;
  155.     char    name[12];
  156.     long    y;
  157.     int    x, icon;
  158.  
  159.     if (shift_pressed())
  160.         del_marke(nr);
  161.     else
  162.     {
  163.         get_marke(nr,name,file,&y,&x);
  164.         if (file[0]!=EOS)
  165.         {
  166.             icon = load_edit(file, FALSE);
  167.             if (icon >= 0)
  168.             {
  169.                 desire_y = y;
  170.                 desire_x = x;
  171.                 icon_edit(icon,DO_GOTO);
  172.             }
  173.         }
  174.     }
  175. }
  176.  
  177. void config_marken(TEXTP t_ptr)
  178. {
  179.     int    antw;
  180.     PATH    file;
  181.     char    name[14];
  182.     long    y;
  183.     int    x, i;
  184.  
  185.     set_state(marken, MRK1, SELECTED, TRUE);
  186.     for (i = 1; i < MARKEN_ANZ; i++)
  187.         set_state(marken, MRK1+i, SELECTED, FALSE);
  188.     for (i=0; i < MARKEN_ANZ; i++)
  189.     {
  190.         get_marke(i, name, file, &y, &x);
  191.         set_string(marken, MRKTXT1+i, name);
  192.     }
  193.     antw = simple_mdial(marken, MRKTXT1);
  194.     if (antw == MRKOK)
  195.     {
  196.         for (i = 0; i < MARKEN_ANZ; i++)
  197.             if (get_state(marken, MRK1 + i, SELECTED))
  198.                 break;
  199.         get_string(marken, MRKTXT1+i, name);
  200.         if (name[0] == EOS)
  201.         {
  202.             file_name(t_ptr->filename, name, FALSE);
  203.             name[MNAME_LEN] = EOS;
  204.         }
  205.         set_marke(i, name, t_ptr->filename, t_ptr->ypos, t_ptr->xpos);
  206.     }
  207. }
  208.  
  209. /***************************************************************************/
  210. /* Verwaltung der Kürzel                                                                    */
  211. /***************************************************************************/
  212.  
  213. void clr_kurzel(void)
  214. {
  215.     free_textring(&kurz);
  216.     free_textring(&auto_kurz);
  217.     krz_loaded = FALSE;
  218. }
  219.  
  220. void do_kurzel(TEXTP t_ptr, bool online)
  221. {
  222.     bool        set_pos, save_insert;
  223.     int        xw, i, len;
  224.     char        *str, buffer[KRZ_MAX_LEN+1];
  225.     ZEILEP    col;
  226.     RINGP        k;
  227.  
  228.     if (online)
  229.         k = &auto_kurz;
  230.     else
  231.         k = &kurz;
  232.  
  233.     if (ist_leer(k))
  234.         return;
  235.  
  236.     xw = t_ptr->xpos;
  237.     if (xw == 0)
  238.         return;
  239.     str = TEXT(t_ptr->cursor_line)+xw;
  240.     i = 0;
  241.     len = min(xw,KRZ_MAX_LEN);
  242.     while (len>0)                                                        /* umdrehen */
  243.     {
  244.         buffer[i++] = *(--str);
  245.         len--;
  246.     }
  247.     buffer[i] = EOS;                                                    /* abschliessen */
  248.  
  249.     /* longest Match */
  250.     for (col=FIRST(k); TRUE; NEXT(col))
  251.     {
  252.         if (IS_TAIL(col))
  253.         {
  254.             if (!online)            /* wenn man Auto-Kürzel hat, pings sonst bei */
  255.                 Bconout(2,7);        /* jedem Zeichen, das kein Kürzel ist! */
  256.             return;
  257.         }
  258.         len = strncmp(buffer,KRZ_TXT(col),KRZ_LEN(col));
  259.         if (len == 0)
  260.             break;
  261.         if (len > 0)
  262.         {
  263.             if (!online)            /* dito. */
  264.                 Bconout(2,7);
  265.             return;
  266.         }
  267.     }
  268.  
  269.     /*
  270.      * Damit während der Kürzelexpandierung NICHT automatisch
  271.      * eingerückt wird, merken wir uns die Einstellung und schalten es ab!
  272.      * Kürzel, die mehrzeilig sind und mit Blanks/TABs beginnen, erscheinen
  273.      * sonst nicht korrekt.
  274.     */
  275.     save_insert = t_ptr->loc_opt->einruecken;
  276.     t_ptr->loc_opt->einruecken = FALSE;
  277.  
  278.     len = KRZ_LEN(col);
  279.     if (overwrite)
  280.         while ((--len)>=0) char_left(t_ptr);
  281.     else
  282.         while ((--len)>=0) char_bs(t_ptr);
  283.     str = ERSATZ(col);
  284.     set_pos = FALSE;
  285.     for (i=col->len-(KRZ_MAX_LEN+2); (--i)>=0; )
  286.     {
  287.         if (*str == '^' && i > 0 && str[1] == '^')
  288.         {
  289.             char_cr(t_ptr);
  290.             restore_edit();                        /* sonst entstehen komische Effekte */
  291.             xw++;
  292.             str++;
  293.             i--;
  294.         }
  295.         else if (*str!='~' || set_pos)        /* das erste '~'-Zeichen zählt */
  296.         {
  297.             char_insert(t_ptr, *str);
  298.             xw++;
  299.         }
  300.         else
  301.         {
  302.             set_pos = TRUE;
  303.             xw = 0;
  304.         }
  305.         str++;
  306.     }
  307.     if (set_pos)
  308.         while ((--xw)>=0) char_left(t_ptr);
  309.  
  310.     /*
  311.      * Und wieder herstellen
  312.     */
  313.     t_ptr->loc_opt->einruecken = save_insert;
  314. }
  315.  
  316. /* return 1 : kein Speicher mehr => abbruch */
  317. /*        0 : alles ok                      */
  318. int add_kurzel(ZEILEP col)
  319. {
  320.     int        len, i;
  321.     char        *str, buffer[MAX_LINE_LEN+1], *start;
  322.     ZEILEP    c;
  323.     bool        online;
  324.  
  325.     krz_loaded = TRUE;
  326.     if (col->len<2)
  327.         return(0);
  328.     if (col->len > MAX_LINE_LEN - KRZ_MAX_LEN)
  329.         return(0);
  330.     if (!ist_mem_frei())
  331.         return (1);
  332.     start = strchr(TEXT(col),'=');                    /* start zeigt auf Ersatztext */
  333.     if (start==NULL)
  334.         return(0);
  335.     start++;
  336.     /* WS am Anfang überspringen */
  337.     for (str=TEXT(col); *str==' ' || *str=='\t'; str++) ;
  338.     if (str[0]=='#' || str[0]=='=' ||
  339.         (str[0]=='*' && str[1]=='='))
  340.         return(0);                                    /* Kommentarzeile oder kein Kurzel */
  341.     len = 0;
  342.     while (len<KRZ_MAX_LEN && *str!=' ' && *str!='\t' && *str!='=')    /* Ende suchen */
  343.     {
  344.         len++; str++;
  345.     }
  346.     if (start[-2]=='*')                                    /* auto. Kürzel */
  347.     {
  348.         online = TRUE;
  349.         if (*str=='=')
  350.         {
  351.             str--;
  352.             len--;
  353.         }
  354.     }
  355.     else
  356.         online = FALSE;
  357.     buffer[0] = len;                                        /* vorne Länge */
  358.     i = 1;
  359.     while (len>0)                                            /* umdrehen */
  360.     {
  361.         buffer[i++] = *(--str);
  362.         len--;
  363.     }
  364.     buffer[i] = EOS;                                        /* abschliessen */
  365.     len = (int) strlen(start);
  366.     memcpy(buffer + KRZ_MAX_LEN + 2, start, len);
  367.     len += (KRZ_MAX_LEN+2);
  368.  
  369.     c = FIRST(&kurz);
  370.     if (ist_leer(&kurz))
  371.         INSERT(&c,0,len,buffer);
  372.     else
  373.     {
  374.         while (!IS_TAIL(c) && strcmp(KRZ_TXT(c),buffer+1)>0)
  375.             NEXT(c);
  376.         col_insert(c->vorg,new_col(buffer,len));
  377.         kurz.lines++;
  378.     }
  379.     if (online)
  380.     {
  381.         c = FIRST(&auto_kurz);
  382.         if (ist_leer(&auto_kurz))
  383.             INSERT(&c,0,len,buffer);
  384.         else
  385.         {
  386.             while (!IS_TAIL(c) && strcmp(KRZ_TXT(c),buffer+1)>0)
  387.                 NEXT(c);
  388.             col_insert(c->vorg,new_col(buffer,len));
  389.             auto_kurz.lines++;
  390.         }
  391.     }
  392.     return(0);
  393. }
  394.  
  395. int load_kurzel(void)
  396. {
  397.     long        anz;
  398.     RING        t;
  399.     ZEILEP    lauf;
  400.     int        erg;
  401.  
  402.     if (krz_name[0] == EOS)
  403.         return 0;
  404.  
  405.     erg = 1;
  406.     init_textring(&t);
  407.     if (load_datei(krz_name, &t, FALSE, NULL) == 0)
  408.     {
  409.         anz = t.lines;
  410.         lauf = FIRST(&t);
  411.         if (anz)
  412.         {
  413.             clr_kurzel();                            /* alte Kürzel löschen */
  414.             while ((--anz)>=0)
  415.             {
  416.                 if (add_kurzel(lauf)) 
  417.                     break;
  418.                 NEXT(lauf);
  419.             }
  420.         }
  421.         erg = 0;
  422.     }
  423.     kill_textring(&t);
  424.     return erg;
  425. }
  426.  
  427. void    ch_kurzel(char *name, bool force_load)
  428. {
  429.     if (name[0] == EOS)
  430.     {
  431.         clr_kurzel();
  432.         krz_name[0] = EOS;
  433.         return;
  434.     }
  435.     if ((strcmp(name, krz_name) != 0) || (force_load))
  436.     {
  437.         strcpy(krz_name, name);
  438.         load_kurzel();
  439.     }
  440. }
  441.